/*
 * CommandLineParser.cpp
 *
 *  Created on:  May 29, 2009
 *      Author:  Zach Riggle A37627537
 *      Project: CSE410 Project 1
 */

#include "CommandLineParser.h"

const string CommandLineParser::commandString = "-c";

CommandLineParser::CommandLineParser(int argc, char** argv) {
    // There must be at least "myexecutable", "-c", "command-to-run" for us to care.
    if (argc < 3)
        return;

    // Check for the "-c" string.
    if (commandString.compare(argv[1]) != 0)
        return;

    /* Okay, we've got our command.  Save it.  Don't worry about the
     dangling space that gets appended. */
    for (int i = 2; i < argc; i++) {
        command.append(argv[i]);
        command.append(" ");
    }

}

//CommandLineParser::CommandLineParser(string s) {
//	class CmdLineArgs : public std::vector<char*>
//	{
//	public:
//	    CmdLineArgs ()
//	    {
//	        // Save local copy of the command line string, because
//	        // ParseCmdLine() modifies this string while parsing it.
//	        PSZ cmdline = GetCommandLine();
//	        m_cmdline = new char [strlen (cmdline) + 1];
//	        if (m_cmdline)
//	        {
//	            strcpy (m_cmdline, cmdline);
//	            ParseCmdLine();
//	        }
//	    }
//	    ~CmdLineArgs()
//	    {
//	        delete m_cmdline;
//	    }
//
//	private:
//	    PSZ m_cmdline; // the command line string
//
//	    ////////////////////////////////////////////////////////////////////////////////
//	    // Parse m_cmdline into individual tokens, which are delimited by spaces. If a
//	    // token begins with a quote, then that token is terminated by the next quote
//	    // followed immediately by a space or terminator.  This allows tokens to contain
//	    // spaces.
//	    // This input string:     This "is" a ""test"" "of the parsing" alg"o"rithm.
//	    // Produces these tokens: This, is, a, "test", of the parsing, alg"o"rithm
//	    ////////////////////////////////////////////////////////////////////////////////
//	    void ParseCmdLine ()
//	    {
//	        enum { TERM  = '\0',
//	               QUOTE = '\"' };
//
//	        bool bInQuotes = false;
//	        PSZ pargs = m_cmdline;
//
//	        while (*pargs)
//	        {
//	            while (isspace (*pargs))        // skip leading whitespace
//	                pargs++;
//
//	            bInQuotes = (*pargs == QUOTE);  // see if this token is quoted
//
//	            if (bInQuotes)                  // skip leading quote
//	                pargs++;
//
//	            push_back (pargs);              // store position of current token
//
//	            // Find next token.
//	            // NOTE: Args are normally terminated by whitespace, unless the
//	            // arg is quoted.  That's why we handle the two cases separately,
//	            // even though they are very similar.
//	            if (bInQuotes)
//	            {
//	                // find next quote followed by a space or terminator
//	                while (*pargs &&
//	                      !(*pargs == QUOTE && (isspace (pargs[1]) || pargs[1] == TERM)))
//	                    pargs++;
//	                if (*pargs)
//	                {
//	                    *pargs = TERM;  // terminate token
//	                    if (pargs[1])   // if quoted token not followed by a terminator
//	                        pargs += 2; // advance to next token
//	                }
//	            }
//	            else
//	            {
//	                // skip to next non-whitespace character
//	                while (*pargs && !isspace (*pargs))
//	                    pargs++;
//	                if (*pargs && isspace (*pargs)) // end of token
//	                {
//	                   *pargs = TERM;    // terminate token
//	                    pargs++;         // advance to next token or terminator
//	                }
//	            }
//	        } // while (*pargs)
//	    } // ParseCmdLine()
//	}; // class CmdLineArgs
//}

CommandLineParser::~CommandLineParser() {
}

string CommandLineParser::getCommand() {
    return command;
}
